package stu.day25_day32.day30;

import java.util.HashMap;
import java.util.Scanner;

public class hw3 {
    static int MOD = 1000000007;
    static long ans = 0;

    // 回溯函数
    static void backtracking(int[] lst, int k, long pathMul, int pathLen, int startIdx) {
        // 若所选取的元素个数大于k，直接返回
        if (pathLen > k) {
            return;
        }
        // 若所选取的元素个数等于k，进行ans的更新
        if (pathLen == k) {
            ans += pathMul;
            ans %= MOD;
            return;
        }
        // 若lst中剩余元素数量即len(lst) - startIdx
        // 已经不足以使得路径path凑够k的长度，进行剪枝
        if (k - pathLen > lst.length - startIdx) {
            return;
        }
        // 进行横向遍历，选择startIdx到len(lst)中的所有索引i，进行回溯
        // 注意三个参数的更新：
        // pathMul参数根据乘法原理，更新为pathMul * lst[i]
        // pathLen参数由于选择的数目增加，路径延长，更新为pathLen + 1
        // startIdx参数由于不可以进行反复选取，需要选择i+1作为下次回溯的起始位置
        for (int i = startIdx; i < lst.length; i++) {
            backtracking(lst, k, (pathMul * lst[i]) % MOD, pathLen + 1, i + 1);
        }
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int k = scanner.nextInt();
        scanner.nextLine();  // 读取换行符

        String input = scanner.nextLine();
        char[] charArray = input.toCharArray();
        HashMap<Character, Integer> cnt = new HashMap<>();
        for (char ch : charArray) {
            cnt.put(ch, cnt.getOrDefault(ch, 0) + 1);
        }

        int[] lst = new int[cnt.size()];
        int idx = 0;
        for (int v : cnt.values()) {
            lst[idx++] = (int) (Math.pow(2, v) - 1);
        }

        if (lst.length < k) {
            System.out.println(0);
        } else {
            ans = 0;
            backtracking(lst, k, 1, 0, 0);
            System.out.println(ans % MOD);
        }
    }
}
